/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class TestCaseManagementService {

    /**
     * Your GET endpoint
     * 列举需求项
     * @returns any OK
     * @throws ApiError
     */
    public static async getListDemand({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 所属产品版本ID
             */
            productVId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 需求列表
         */
        demands: Array<{
            /**
             * 需求ID
             */
            id: number,
            /**
             * 需求名称
             */
            name: string,
            /**
             * 重要级别，可取值：
             * 0-重要，1-较重要，2-普通
             */
            level: number,
            /**
             * 统一需求ID
             */
            demandOpenId: string,
            /**
             * 描述
             */
            description: string,
            /**
             * 是否已添加为用例树结点，可取值：
             * 0-未添加，1-已添加
             */
            hasAdd: number,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/casemanager/v1/list-demand`,
            body: requestBody,
        });

        __checkJsonSchema("getListDemand", schemas, result);
        return result.body;
    }

    /**
     * 新增一个用例
     * @returns any Example response
     * @throws ApiError
     */
    public static async addCase({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 所属产品版本ID，无需求项下的用例添加时必填
             */
            productVId?: number,
            /**
             * 所属需求ID
             */
            demandId: number,
            /**
             * 用例名称
             */
            name: string,
            /**
             * 用例类型，可取值：
             * flowchart - 图形流
             * java - 用户上传java代码
             * jmeter - 用户上传jmeter脚本
             * rf - 用户上传rf脚本
             */
            type: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/casemanager/v1/add-case`,
            body: requestBody,
        });

        __checkJsonSchema("addCase", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举需求/用例，以树状结构呈现
     * @returns any OK
     * @throws ApiError
     */
    public static async getListCasetree({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 产品版本ID
             */
            productVId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: string,
        /**
         * 用例树结点列表
         */
        caseTree: Array<{
            /**
             * 需求/用例ID
             */
            id: number,
            /**
             * 需求/用例名称
             */
            name: string,
            /**
             * 结点类型，可取值：
             * 1-需求项，2-用例项，3-无需求项
             */
            type: number,
            /**
             * 用例类型，仅当type=2时有值，可取值：
             * flowchart - 图形流
             * java - 用户上传java代码
             * jmeter - 用户上传jmeter脚本
             * rf - 用户上传rf脚本
             */
            caseType?: string,
            /**
             * 目标脚本类型，仅当type=2时有值，可取值：jmeter、rf
             */
            target?: string,
            /**
             * 编译状态，仅当type=2时有值，可取值：
             * notcompile - 未编译
             * compiling - 正在编译
             * compiled - 已编译
             * compilefail - 编译失败
             * norequired - 无需编译
             */
            status?: string,
            /**
             * 创建日期，仅当type=2时有值
             */
            createTime?: string,
            /**
             * 最新修改日期，仅当type=2时有值
             */
            updateTime?: string,
            /**
             * 最新修改人，仅当type=2时有值
             */
            updateUser?: string,
            /**
             * 子结点列表，仅当type=1或3时有值
             */
            children?: Array<any>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/casemanager/v1/list-casetree`,
            body: requestBody,
        });

        __checkJsonSchema("getListCasetree", schemas, result);
        return result.body;
    }

    /**
     * 删除用例树的一个结点
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteCasetreeNode({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 所属产品版本ID
             */
            productVId: number,
            /**
             * 需求/用例ID
             */
            id: number,
            /**
             * 结点类型，可取值：1-需求项，2-用例项
             */
            type: number,
            /**
             * 是否删除子结点，仅当type=1时必填，可取值：0-不删，1-删除
             */
            delChildren?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/casemanager/v1/del-node`,
            body: requestBody,
        });

        __checkJsonSchema("deleteCasetreeNode", schemas, result);
        return result.body;
    }

    /**
     * 上传某个用例的jmx/rf脚本、或java代码包
     * @returns any Example response
     * @throws ApiError
     */
    public static async uploadScript({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * jmx或robot或zip文件
             */
            file: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/scriptmanager/v1/upload`,
            body: requestBody,
        });

        __checkJsonSchema("uploadScript", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 下载某个用例的jmx/rf脚本、或java代码包
     * @returns any OK
     * @throws ApiError
     */
    public static async downloadScript({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例 ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * jmx/robot脚本文件或zip代码压缩包
         */
        File: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/scriptmanager/v1/download`,
            body: requestBody,
        });

        __checkJsonSchema("downloadScript", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 上传Java工程模板
     * @returns any Example response
     * @throws ApiError
     */
    public static async uploadTemplate({
        requestBody,
    }: {
        requestBody?: {
            /**
             * zip文件
             */
            file: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/scriptmanager/v1/upload-template`,
            body: requestBody,
        });

        __checkJsonSchema("uploadTemplate", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 下载Java工程模板（包括rest-api.jar）
     * @returns any OK
     * @throws ApiError
     */
    public static async downloadTemplate({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 产品版本ID
             */
            productVId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * jmx/robot脚本文件或zip代码压缩包
         */
        File: string,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/scriptmanager/v1/get-template`,
            body: requestBody,
        });

        __checkJsonSchema("downloadTemplate", schemas, result);
        return result.body;
    }

    /**
     * 编译图形流用例、Java代码用例
     * @returns any Example response
     * @throws ApiError
     */
    public static async doCompile({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/casecompilemanager/v1/do-compile`,
            body: requestBody,
        });

        __checkJsonSchema("doCompile", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举某个用例的编译记录
     * @returns any OK
     * @throws ApiError
     */
    public static async getCompileRecords({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 用例ID
             */
            caseId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 编译记录列表
         */
        records: Array<{
            /**
             * 记录ID，对应Mongo主键
             */
            id: string,
            /**
             * 编译起因，可取值：
             * RestAPIChange – 用户修改RestAPI
             * UserCompile – 用户点击编译
             */
            compileFor: string,
            /**
             * 编译结果，可取值：
             * success – 成功
             * fail – 失败
             * compiling – 编译中
             */
            result: string,
            /**
             * 编译时间
             */
            compileTime: string,
            /**
             * 编译记录的事件列表
             */
            events: Array<{
                /**
                 * 事件内容，比如：java代码编译完成、jmx编译完成、rf编译失败，失败原因：xxx
                 */
                content: string,
                /**
                 * 事件时间
                 */
                eventTime: string,
            }>,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/casecompilemanager/v1/list-records`,
            body: requestBody,
        });

        __checkJsonSchema("getCompileRecords", schemas, result);
        return result.body;
    }

}